home *** CD-ROM | disk | FTP | other *** search
/ Mission 3 / Mission 3.zip / Mission 3.iso / demovers / scripter / demo / gsplot.sic < prev    next >
Text File  |  1998-09-26  |  4KB  |  179 lines
  1. //ACE-SICPAR 8 0080 
  2. /*
  3.  * Funktionsplotter fuer GEMstat
  4.  * Aufruf ohne Parameter: Funktion und Bereich werden per Dialog abgefragt
  5.  * Mit Parameter: gsplot.sic "Funktion" Start Ende
  6.  * Start und Ende sind optional und defaultmaessig -1 bzw. 1
  7.  * "Funktion" ist ein String wie z.B. "x * sin(x) - 1"
  8.  * Der Parameter ist immer x
  9.  */
  10. uses "math.lib";
  11.  
  12. /*
  13.  * Hauptfunktion
  14.  */
  15. proc main(...)
  16. local StartWert, EndWert, Funktion;
  17. {
  18.     StartWert = -1.0;   // Defaultwerte, falls nicht angegeben
  19.     EndWert = 1.0;
  20.  
  21.     precision(8);        // Zum Malen in GEMstat reicht das vollkommen aus
  22.  
  23.     /*
  24.      * Anmerkung: Die Anzahl der Werte koennte man vielleicht von der
  25.      * Fensterbreite abhaengig machen. Dazu muesste man sie aus GEMstat
  26.      * auslesen koennen. Oder man laesst sie direkt irgendwo einstellen.
  27.      */
  28.     Anzahl_der_Werte = 80;
  29.     WertePaare.length = Anzahl_der_Werte * 2;
  30.  
  31.     /*
  32.      * Je nachdem, ob Parameter uebergeben wurden, werden diese
  33.      * benutzt oder die Funktion und der Bereich per Dialog abgefragt.
  34.      */
  35.     switch (argc) {
  36.         default: EndWert = float(argv[2]);
  37.         case 2: StartWert = float(argv[1]);
  38.         case 1: Funktion = string(argv[0]);
  39.             translate(f, "", "return " + Funktion + ";");
  40.             break;
  41.  
  42.         case 0: Funktion = FunktionsEingabe();
  43.             BereichsEingabe(StartWert, EndWert);
  44.             break;
  45.     }
  46.  
  47.     /*
  48.      * Hier wird geplottet. In der Variablen 'Funktion' steht jetzt noch
  49.      * der Ausdruck als String und koennte auch benutzt werden, um ihn
  50.      * im Fenster auszugeben.
  51.      */
  52.     plot(StartWert, EndWert);
  53. }
  54.  
  55.  
  56. /*
  57.  * Die Wertepaare ausrechnen und anschliessend an GEMstat senden
  58.  */
  59. proc plot(start, end)
  60. local i, x, width;
  61. {
  62.     /*
  63.      * Startwert sollte kleiner als Endwert sein
  64.      */
  65.     if (start >= end) throw("bad range", start, end);
  66.  
  67.     /*
  68.      * Schrittweit zwischen den einzelnen x-Werten berechnen
  69.      */
  70.     width = (end - start) / (Anzahl_der_Werte - 1);
  71.  
  72.     /*
  73.      * Werte von <start> bis <end> berechnen und plotten
  74.      */
  75.     for (i = 0, x = start; i < (Anzahl_der_Werte * 2); i += 2, x += width) {
  76.         WertePaare[i] = x;
  77.         WertePaare[i + 1] = f(x);
  78.     }
  79.  
  80.     /*
  81.      * Werte zum Plotten an GEMstat, oder wen auch immer, uebergeben
  82.      */
  83.     gemstat.plot(WertePaare);
  84. }
  85.  
  86.  
  87. /*
  88.  * Abfragen der Funktion, die geplottet werden soll.
  89.  */
  90. proc FunktionsEingabe()
  91. local Term, Selektion, FunktionsDefinition;
  92. {
  93.     Term = "";
  94.  
  95.     do {
  96.         /*
  97.          * Eingabe in einem Dialog machen, der mit OK beendet werden muss.
  98.          */
  99.         Selektion = "Keine";
  100.         FunktionsDefinition = dialog.input("Funktion f(x) eingeben:", Term);
  101.         if (FunktionsDefinition[0] != "OK") exit(0);
  102.         Term = FunktionsDefinition[1];
  103.  
  104.         /*
  105.          * Hier wird die Funktion uebersetzt. Alle Uebersetzungsfehler
  106.          * werden abgefangen (durch catch("*")) und in diesem Fall wird
  107.          * nachgefragt, ob die Eingabe wiederholt werden soll.
  108.          */
  109.         try {
  110.             translate(f, "", "return " + Term + ";");
  111.         }
  112.         catch ("*") {
  113.             Selektion = dialog.note("Fehler im Ausdruck:",
  114.                         ExceptionData[0],
  115.                         "-bNochmal", "-bAbbruch");
  116.         }
  117.  
  118.         if (Selektion == "Abbruch") exit(0);
  119.  
  120.     } while (Selektion == "Nochmal");
  121.  
  122.     return Term;
  123. }
  124.  
  125.  
  126. /*
  127.  * Abfragen des x-Bereiches, der geplottet werden soll.
  128.  */
  129. proc BereichsEingabe(&Start, &Ende)
  130. local Bereich, Selektion, BereichsDefinition, StartEnd;
  131. {
  132.     Bereich = string(Start) + ", " + string(Ende);
  133.  
  134.     do {
  135.         /*
  136.          * Den Bereich in einem Dialog eingeben lassen. Die Eingabe muss
  137.          * in der Form Startwert, Endwert erfolgen.
  138.          */
  139.         Selektion = "Keine";
  140.         BereichsDefinition = dialog.input("Bereich eingeben (Start, Ende):", Bereich);
  141.         if (BereichsDefinition[0] != "OK") exit(0);
  142.  
  143.         /*
  144.          * Die Eingabe war in Ordnung, wenn zwei durch Komma getrennte
  145.          * Werte eingegeben wurden und der Startwert kleiner dem
  146.          * Endwert ist. Ansonsten wird gefragt, ob die Eingabe
  147.          * wiederholt werden soll.
  148.          */
  149.         StartEnd = split(BereichsDefinition[1], ", ");
  150.         if (StartEnd.length != 2) {
  151.             dialog.note("Fehler in der Eingabe:", BereichsDefinition[1],
  152.                     "Anzahl der Werte ungleich 2",
  153.                     "-bNochmal", "-bAbbruch");
  154.         }
  155.         else {
  156.             Start = float(StartEnd[0]);
  157.             Ende = float(StartEnd[1]);
  158.  
  159.             if (Start >= Ende) {
  160.                 dialog.note("Fehler in der Eingabe:",
  161.                         "Start muss kleiner als Ende sein",
  162.                         "-bNochmal", "-bAbbruch");
  163.             }
  164.         }
  165.  
  166.         if (Selektion == "Abbruch") exit(0);
  167.  
  168.     } while (Selektion == "Nochmal");
  169. }
  170.  
  171.  
  172. /*
  173.  * In diese Funktion wird der Ausdruck uebersetzt
  174.  */
  175. proc f(x)
  176. {
  177.     return x;
  178. }
  179.